home *** CD-ROM | disk | FTP | other *** search
/ Commodore Free 7 / Commodore_Free_Issue_07_2007_Commodore_Computer_Club.d64 / t.hexfiles 2 < prev    next >
File List  |  2023-02-26  |  6KB  |  207 lines
  1. uHEX FILES PART 2 *
  2.  
  3. Hello all and welcome to the second
  4. part of this course for budding
  5. Commodore 64 programmers. In the
  6. previous instalment we got to grips
  7. with the basics of the C64 itself and
  8. introduced a first batch of assembly
  9. language commands that, after they're
  10. converted to machine code, our C64
  11. can understand.
  12.  
  13. This time around, I plan to bring a few
  14. more in to play as well as expand on
  15. what's gone before. To begin with,
  16. LDA and LDX have both been covered
  17. independently last time but they can
  18. also work together to much greater
  19. effect - so lets get things off to a
  20. start straight away with the first
  21. little example:
  22.  
  23. ldx #$00; set X register to zero
  24. lda #$01; set accumulator to zero
  25. sta $0400,x; store contents of A into
  26.  $0400+X
  27. rts
  28.  
  29. If we were to run this, a letter A
  30. would appear at the top left corner of
  31. our screen. Nothing exiting so far, huh
  32. Well, if we were to alter the first
  33. command to read LDX #$01 and re-
  34. run it the results would be slightly
  35. different in that the A would now be
  36. one character to the right.
  37.  
  38. So how does this actually work you
  39. ask. Well, the first command sets the
  40. value in the X register and the second
  41. sets the accumulator (A register) in
  42. the same way as before. But the STA
  43. command has been altered slightly so
  44. that instead of just putting the
  45. contents of A to a set place (in this
  46. case memory location 1,024) it adds the
  47. value in X to the location. So if X is
  48. 0 then the A character appears at 1,024
  49. & if it were 40 then the A will be one
  50. line down because there are forty
  51. characters a line. This is the basics
  52. of loops in machine code, but before we
  53. can introduce them properly we need
  54. to first look at another facet of
  55. machine code. When writing code it is
  56. necessary to leap back & forth thru the
  57. program in the same way that BASIC can
  58. with GOTO's & GOSUB's.
  59.  
  60. Because we have no line numbers we
  61. need some way of identifying a piece
  62. of code to jump to which is what labels
  63. do. A label is not actually a command
  64. its a word, but it's like naming a
  65. piece of your program so that you can
  66. then refer to it by that name. Classic
  67. examples are calling a loop loop or
  68. your control routine readstick (for
  69. reading the joystick) but just about
  70. any word that doesn't have an instruct-
  71. ion in can be used. Labels do have
  72. other uses which we will cover later
  73. but for now I'll leave this definition.
  74.  
  75. Time for another example I think, this
  76. time showing the use of a label and our
  77. next two commands. This next example
  78. would, if executed, put eight A's at
  79. the top left of the screen:
  80.  
  81. Ldx #$00; set X register to zero
  82. lda #$01; put 1 in the accumulator loop
  83. sta $0400,x; our very first label!
  84. inx; INcrement X (as before)
  85. cpx #$08   ; ComPare X to see if it's 8
  86. bne loop  ; Branch if Not Equal to loop
  87. rts; exit
  88.  
  89. Why have I confused you and introduced
  90. two new commands together? Well, lets
  91. cover each command in turn. First, CPX
  92. is short for ComPare X & its job is to
  93. compare things to the X register
  94. (fairly obvious, eh?) In the example
  95. above we are checking to see if X has
  96. the value of #$08 but if we wanted to
  97. put say nine A's we merely change the
  98. command to CPX #$09. But when we have
  99. done this comparison we need to then do
  100. something with the results. And this is
  101. where Branch if Not Equal, or BNE
  102. comes in.
  103.  
  104. The basic flow of this loop goes like
  105. thus. We put a zero in X and a one in
  106. A (for character 1, which is the A we
  107. would see on screen). Then we hit the
  108. main loop which puts the contents of A
  109. into location $0400 + X, which is
  110. $0400 since X is zero. Then we add
  111. one to X and compare it to eight to see
  112. if it's reached the end, if not we
  113. branch back to loop & put another
  114. character down at $0400 + X (which is
  115. now $0401 since X is 1). This continues
  116. until X does reach eight. When this
  117. happens the BNE is ignored (after all,
  118. it is equal now) and we fall through to
  119. the end.
  120.  
  121. Some of you may be a bit confused by
  122. this logic, thinking that since we stop
  123. when X reaches eight then surely the
  124. eighth character wouldn't appear on
  125. screen because the loop would stop,
  126. but it makes more sense when you
  127. remember that we are counting from zero
  128. & not one.
  129.  
  130. So far we have been examining routines
  131. purely in theory but I'm sure we are
  132. getting to the point where all of you
  133. want to start seeing results from your
  134. code. From here onwards, we'll be using
  135. the C64Asm cross assembler, although
  136. the source is fully compatible with the
  137. native Turbo Assembler for now. To
  138. start you all off I'll just give
  139. you the basics of starting it up & we
  140. will enter the previous example as
  141. source code and show it working.
  142.  
  143. Because we are now moving into the
  144. "real" world of programming the
  145. listing is slightly different. First,
  146. open a copy of Notepad (or your text
  147. editor of choice) & enter the following
  148. variation on the code we've seen thus
  149. far:
  150.  
  151. * = $0900
  152. ldx #$00
  153. lda #$01 loop
  154. sta $0400,x
  155. inx
  156. cpx #$08
  157. bne loop
  158. rts
  159.  
  160. The only difference is the * = $0900 at
  161. the top; this is a command to tell the
  162. assembler where we want our code to
  163. go (in this case $0900 in memory,
  164. which is 2304 in decimal). Now we
  165. want to see our code going, so it's
  166. time to assemble it. First, save the
  167. file out as "test.txt" & then you'll
  168. need to navigate to the same directory
  169. in DOS & type c64asm test.txt
  170. program.prg & you should see the
  171. following appear:
  172.  
  173. Assembling TEST.TXT
  174. PROGRAM.PRG created from $9000 to $090c
  175.  
  176. Now that's a happy bunny, it can be fed
  177. to a passing emulator or moved to a
  178. real C64 and tested; to try it in
  179. WinVICE simply drag the PRG file over
  180. to the emulator's window & drop it,
  181. then type SYS2304 and voila - your very
  182. first machine code program!
  183.  
  184. Well, that's the second part over with
  185. but before you carry on to the next
  186. installment I'll leave you with a
  187. little challenge. Can you figure out
  188. how to change our example to put eleven
  189. characters on the screen in the listing
  190. above & change them from "A" to "C"?
  191. Why not play with the code & see what
  192. you can come up with! If you have any
  193. questions about this article or
  194. machine code in general, email me &
  195. I'll order an economy size tub of rice
  196. pudding and come round to yours. The
  197. source code for the routines above can
  198. be downloaded here for easier
  199. reference.
  200.  
  201. http://www.oldschoolgaming.com/files
  202. /c64/hex_files/part_2_files.zip
  203.  
  204. Printed with owners pemission
  205. [ Jason Kelk ]:
  206. http://www.oldschoolgaming.com
  207.